/*****************************************Copyright(C)******************************************
****************************************** *********************************************
*------------------------------------------文件信息---------------------------------------------
* FileName          : modbus_master.c
* Author            : 张婷颖
* Version           : 1.0V
* Description       : 
*----------------------------------------历史版本信息-------------------------------------------
* History           :
* Description       :
*-----------------------------------------------------------------------------------------------
***********************************************************************************************/
/* Includes-----------------------------------------------------------------------------------*/
#include "modbus_master.h"
#include "crc16.h"
#include "Bsp_uart.h"
#include "user_protocol.h"

#if MODBUS | MODBUS_TCP
#include <stdio.h>
#include <stdlib.h>
/* Private define-----------------------------------------------------------------------------*/

/* Private typedef----------------------------------------------------------------------------*/

/* Private macro------------------------------------------------------------------------------*/

/* Private variables--------------------------------------------------------------------------*/

//uint16_t m_ask_crc;                                                    //主站应答CRC

//WARPER_ADDR device_read_addr = COIL_GT600_ETHERNET_FAULT;

//INOVANCE_ADDR device_read_addr = DEVICE_STATUS_ADDR;
//INOVANCE_ADDR device_write_addr = LOWER_BEAM_SUM_LENGTH_ADDR_L;

//MASTER_STATUS_T master_status;
//uint8_t send_count = 0;

//uint8_t coil_state[COIL_SIZE];                                          //线圈状态
//uint16_t rebuf_into[REGISTER_SIZE];                                     //寄存器    (暂时用做，数据采集缓存区

//FRAME_INFO m_recvinfo;                                                 //接收到的信息帧
//FRAME_INFO m_txinfo;                                                   //应答信息帧
//M_DATA_INFO m_rx_data;                                                  //接收数据域
//M_DATA_INFO m_tx_data;                                                  //应答数据域

uint16_t read_buf_len = 0;                                              //已经读取的寄存器数量
//uint8_t read_finish = 1;                                                //读取完成标志位
/* Private function prototypes----------------------------------------------------------------*/

/* Private functions--------------------------------------------------------------------------*/
/************************************************
函数名称 ： refresh_info
功    能 ：刷新信息帧，清楚记录
参    数 ：info 发送信息帧或者接收信息帧
返 回 值 ：
*************************************************/
void refresh_info(INFO_COMBINATION *sum_info)
{
	sum_info->rx_data.buf_header_add = 0;
	sum_info->rx_data.buf_num = 0;
	sum_info->rx_data.data_len = 0;
	sum_info->rx_data.exception_code = NO_ERROR;
	for(int i = 0;i < ONCE_REGISTER_SIZE;i++)
		sum_info->rx_data.buf_rwdata[i]=0;

	sum_info->recvinfo.device_address = 0;
	sum_info->recvinfo.funcode = NO_FUNCODE;
	sum_info->recvinfo.event_code = 0;
	sum_info->recvinfo.crc_info = 0;

	sum_info->tx_data.buf_header_add = 0;
	sum_info->tx_data.buf_num = 0;
	sum_info->tx_data.data_len = 0;
	sum_info->tx_data.exception_code = NO_ERROR;
	for(int i = 0;i < ONCE_REGISTER_SIZE;i++)
		sum_info->tx_data.buf_rwdata[i]=0;

	sum_info->txinfo.device_address = 0;
	sum_info->txinfo.funcode = NO_FUNCODE;
	sum_info->txinfo.crc_info = 0;
	sum_info->txinfo.event_code = 0;
}

#if MODBUS
/************************************************
函数名称 ： refresh_info
功    能 ：刷新信息帧，清楚记录
参    数 ：info 发送信息帧或者接收信息帧
返 回 值 ：
*************************************************/
void rerequest(INFO_COMBINATION *sum_info)
{
	sum_info->send_count++;
	if(sum_info->send_count <= SEND_MAX)                                            //重发次数未超时，重发，本次请求还未清除，可以直接用
		M_ask_tx_data(&(sum_info->txinfo),&(sum_info->tx_data),&(sum_info->master_status));
	else                                                                  //超出重试次数，放弃请求 本次请求，响应清空，重置重发次数
	{
		sum_info->master_status = ABANDON_REQUEST;
		refresh_info(sum_info);
		sum_info->send_count = 0;
	}
//	send_count++;
//	if(send_count <= SEND_MAX)                                            //重发次数未超时，重发，本次请求还未清除，可以直接用
//		M_ask_tx_data(sum_info->txinfo,sum_info->tx_data);
//	else                                                                  //超出重试次数，放弃请求 本次请求，响应清空，重置重发次数
//	{
//		master_status = ABANDON_REQUEST;
//		refresh_info(sum_info);
//		send_count = 0;
//	}

}
/************************************************
函数名称 ： GetFrameInformation
功    能 ：获取接收到帧的信息
参    数 ：pdata 接收到的信息   len 接收到的信息长度   *m_recvinfo 分解后信息存入这个结构体指针
返 回 值 ： 
*************************************************/
static void M_GetFrameInformation(uint8_t *pdata,uint8_t len,FRAME_INFO *m_recvinfo)
{
	m_recvinfo->device_address = *(pdata + 0);                            //从站地址
	m_recvinfo->funcode = *(pdata + 1);                                   //功能码
	m_recvinfo->pdata = pdata+2;                                          //指向具体数据
	m_recvinfo->crc_info = (*(pdata + len - 2)<<8)|(*(pdata + len - 1));  //CRC校验值  最后2位
}

//static void M_GetFrameInformation(uint8_t *pdata,uint8_t len)
//{
//	m_recvinfo.device_address = *(pdata + 0);                            //从站地址
//	m_recvinfo.funcode = *(pdata + 1);                                   //功能码
//	m_recvinfo.pdata = pdata+2;                                          //指向具体数据
//	m_recvinfo.crc_info = (*(pdata + len - 2)<<8)|(*(pdata + len - 1));  //CRC校验值  最后2位
//}
/************************************************
函数名称 ： M_Analyse_info
功    能 ： 分析接收到的信息帧
参    数 ： p 接收缓存首地址   len  接收数据长度
返 回 值 ： 无
*************************************************/
uint8_t M_Analyse_info(uint8_t *p, uint8_t Len, INFO_COMBINATION *sum_info)
{
	uint16_t m_user_crc;                                                   //计算CRC
	// 为m_recvinfo的指针成员分配内存,MODBUS最大数据长度250，避免内存泄漏和悬挂指针问题，使用结束释放内存
	//if(sum_info->recvinfo.pdata == NULL)  //20240530
	//{
		sum_info->recvinfo.pdata = (uint8_t *)malloc(250);
	//}
    if(sum_info->recvinfo.pdata == NULL)                                   // 检查内存分配是否成功
    {
    	printf("memory allocation failure");
    	return 0;                                                          // 返回错误代码
    }

	if(Len < FIXEDLEN)                                                     //不足一帧数据最小长度,返回0
		return 0;
	M_GetFrameInformation(p,Len,&sum_info->recvinfo);                      //获取信息帧内容

	if(sum_info->recvinfo.device_address == sum_info->txinfo.device_address)      //设备地址对应
	{
		m_user_crc = Computer_CRC16(p,Len - 2);                            //计算CRC（功能码0-6）
		if(m_user_crc == sum_info->recvinfo.crc_info)                      //crc校验成功
		{
			M_Dealwith(sum_info);                                          //获取接收数据域中的内容  处理对应功能码及应答
			return 1;
		}
		else
			return 0;
	}
	else
		return 0;
}

//uint8_t M_Analyse_info(uint8_t *p,uint8_t Len)
//{
//
//	if(Len<FIXEDLEN)                                                             //不足一帧数据最小长度,返回0
//		return 0;
//	M_GetFrameInformation(p,Len);                                                //获取信息帧内容
//
//	if(m_recvinfo.device_address == MY_ADDRESS_WARPER)                                  //设备地址对应
//	{
//		m_user_crc = Computer_CRC16(p,Len - 2);                                  //计算CRC（功能码0-6）
//		if(m_user_crc == m_recvinfo.crc_info)                                    //crc校验成功
//		{
//			M_Dealwith(m_recvinfo.pdata);                                      //获取接收数据域中的内容  处理对应功能码及应答
//
//			return 1;
//		}
//		else
//			return 0;
//	}
//	else
//		return 0;
//
//}
/************************************************
函数名称 ： M_ask_tx_data
功    能 ： 请求新数据
参    数 ：请求数据的信息
返 回 值 ： 无
*************************************************/
void M_ask_tx_data(FRAME_INFO *tx_info,M_DATA_INFO *tx_data_info,MASTER_STATUS_T *master_status)
{
	uint8_t askp[40] = {0};                                        //应答缓存    （包含CRC）
	uint8_t i=0;
	askp[i++] = tx_info->device_address;                            //从站地址
	askp[i++] = tx_info->funcode;                                   //功能码
	askp[i++] = tx_data_info->buf_header_add >> 8;                  //寄存器起始位置高字节
	askp[i++] = tx_data_info->buf_header_add;                       //寄存器起始位置低字节
	switch(tx_info->funcode)
	{
		case(FUNCODE_01):
		case(FUNCODE_02):
		case(FUNCODE_03):
		case(FUNCODE_04):
					askp[i++] = tx_data_info->buf_num >> 8;          //读取线圈/寄存器数量高字节
					askp[i++] = tx_data_info->buf_num;               //读取线圈/寄存器数量低字节
					break;
		case(FUNCODE_05):
		case(FUNCODE_06):
					askp[i++] = tx_data_info->buf_rwdata[0] >> 8;     //写入一个线圈/寄存器的高字节
					askp[i++] = tx_data_info->buf_rwdata[0];          //写入一个线圈/寄存器的低字节
					break;
		case(FUNCODE_0F):
					askp[i++] = tx_data_info->buf_num >> 8;           //写入线圈数量
					askp[i++] = tx_data_info->buf_num;
					tx_data_info->data_len = tx_data_info->buf_num / 8;
					if(tx_data_info->buf_num % 8)
						tx_data_info->data_len++;
					askp[i++] = tx_data_info->data_len;               //写入数据字节数 （线圈数量/8 + （线圈数量%8)）
					for(int j = 0;j < tx_data_info->data_len;j++)
						askp[i + j] = tx_data_info->buf_rwdata[j];
					i += tx_data_info->data_len;
					break;
		case(FUNCODE_10):
					askp[i++] = tx_data_info->buf_num >> 8;           //写入寄存器数量
					askp[i++] = tx_data_info->buf_num;
					tx_data_info->data_len = tx_data_info->buf_num * 2;
					askp[i++] = tx_data_info->data_len;               //写入数据字节数(一个数据2字节)  （寄存器数量*2）
					for(int j = 0,a = 0;j < tx_data_info->data_len;j += 2)
					{
						askp[i + j] = tx_data_info->buf_rwdata[a] >> 8;
						askp[i + j + 1] = tx_data_info->buf_rwdata[a];
						a++;
					}
					i += tx_data_info->data_len;
		default:    break;
	}
	Computer_CRC16(askp,i);                                        //计算CRC
	askp[i++] = crcH;                                              //CRC高字节
	askp[i++] = crcL;                                              //CRC低字节
#if RS232_232_1 || MODBUS_232_1
	Send_Data(&huart4,askp,i);                                     //发送
#endif
#if MODBUS_485
	Send_Data(&huart6,askp,i);                                     //发送
#endif
	time_count = 0;                                                //重新响应计时
	*master_status = START_REQUEST;                                 //主站状态，开始请求
//	uint8_t askp[40] = {0};                                        //应答缓存    （包含CRC）
//	uint8_t i=0;
//	askp[i++] = tx_info.device_address;                            //从站地址
//	askp[i++] = tx_info.funcode;                                   //功能码
//	askp[i++] = tx_data_info.buf_header_add >> 8;                  //寄存器起始位置高字节
//	askp[i++] = tx_data_info.buf_header_add;                       //寄存器起始位置低字节
//	switch(tx_info.funcode)
//	{
//		case(FUNCODE_01):
//		case(FUNCODE_02):
//		case(FUNCODE_03):
//		case(FUNCODE_04):
//					askp[i++] = tx_data_info.buf_num >> 8;          //读取线圈/寄存器数量高字节
//					askp[i++] = tx_data_info.buf_num;               //读取线圈/寄存器数量低字节
//					break;
//		case(FUNCODE_05):
//		case(FUNCODE_06):
//					askp[i++] = tx_data_info.buf_rwdata[0] >> 8;     //写入一个线圈/寄存器的高字节
//					askp[i++] = tx_data_info.buf_rwdata[0];          //写入一个线圈/寄存器的低字节
//					break;
//		case(FUNCODE_0F):
//					askp[i++] = tx_data_info.buf_num >> 8;           //写入线圈数量
//					askp[i++] = tx_data_info.buf_num;
//					tx_data_info.data_len = tx_data_info.buf_num / 8;
//					if(tx_data_info.buf_num % 8)
//						tx_data_info.data_len++;
//					askp[i++] = tx_data_info.data_len;               //写入数据字节数 （线圈数量/8 + （线圈数量%8)）
//					for(int j = 0;j < tx_data_info.data_len;j++)
//						askp[i + j] = tx_data_info.buf_rwdata[j];
//					i += tx_data_info.data_len;
//					break;
//		case(FUNCODE_10):
//					askp[i++] = tx_data_info.buf_num >> 8;           //写入寄存器数量
//					askp[i++] = tx_data_info.buf_num;
//					tx_data_info.data_len = tx_data_info.buf_num * 2;
//					askp[i++] = tx_data_info.data_len;               //写入数据字节数(一个数据2字节)  （寄存器数量*2）
//					for(int j = 0,a = 0;j < tx_data_info.data_len;j += 2)
//					{
//						askp[i + j] = tx_data_info.buf_rwdata[a] >> 8;
//						askp[i + j + 1] = tx_data_info.buf_rwdata[a];
//						a++;
//					}
//					i += tx_data_info.data_len;
//		default:    break;
//	}
//	Computer_CRC16(askp,i);                                        //计算CRC
//	askp[i++] = crcH;                                              //CRC高字节
//	askp[i++] = crcL;                                              //CRC低字节
//#if RS232_232_1 || MODBUS_232_1
//	Send_Data(&huart4,askp,i);                                     //发送
//#endif
//#if MODBUS_485
//	Send_Data(&huart1,askp,i);                                     //发送
//#endif
//	time_count = 0;                                                //重新响应计时
//	sum_info->master_status = START_REQUEST;                                 //主站状态，开始请求
}


/************************************************
函数名称 ： M_achieves_read
功    能 ： modbus主站测试读取       功能码0x01-0x04
参    数 ：funcode 功能码
			buf_add 寄存器/线圈首地址
			num 寄存器/线圈个数
返 回 值 ： 无
*************************************************/
void M_achieves_read(uint16_t device_address,FUNCODE_T funcode,uint16_t buf_add,uint8_t num,INFO_COMBINATION *sum_info)
{
	sum_info->txinfo.device_address = device_address;
	sum_info->txinfo.funcode = funcode;
	sum_info->tx_data.buf_header_add = buf_add;
	sum_info->tx_data.buf_num = num;
	M_ask_tx_data(&(sum_info->txinfo),&(sum_info->tx_data),&(sum_info->master_status));
}
//void M_achieves_read(FUNCODE_T funcode,uint16_t buf_add,uint8_t num)
//{
//	m_txinfo.device_address = MY_ADDRESS_WARPER;
//	m_txinfo.funcode = funcode;
//	m_tx_data.buf_header_add = buf_add;
//	m_tx_data.buf_num = num;
//	M_ask_tx_data(m_txinfo,m_tx_data);
//}
/************************************************
函数名称 ： M_achieves_write
功    能 ： modbus主站测试写入       功能码5 6 15 16
参    数 ：funcode 功能码
			buf_add 寄存器/线圈首地址
			num 寄存器/线圈个数
			buf 写入数据
返 回 值 ： 无
*************************************************/
void M_achieves_write(uint16_t device_address,FUNCODE_T funcode,uint16_t buf_add,uint8_t num,uint16_t *buf, INFO_COMBINATION *sum_top)
{
	sum_top->txinfo.device_address = device_address;
	sum_top->tx_data.buf_header_add = buf_add;
	sum_top->txinfo.funcode = funcode;
	sum_top->tx_data.buf_num = num;
	switch (sum_top->txinfo.funcode)
	{
		case FUNCODE_05:
				break;
		case FUNCODE_0F:
				break;
		case FUNCODE_06:
		case FUNCODE_10:
				for(int i = 0;i < sum_top->tx_data.buf_num;i++)
					sum_top->tx_data.buf_rwdata[i] = *(buf + i);
				break;
		default:
			break;
	}
	M_ask_tx_data(&(sum_top->txinfo),&(sum_top->tx_data),&(sum_top->master_status));
}
//void M_achieves_write(FUNCODE_T funcode,uint16_t buf_add,uint8_t num,uint16_t *buf)
//{
//	m_txinfo.device_address = MY_ADDRESS_WARPER;
//	m_tx_data.buf_header_add = buf_add;
//	m_txinfo.funcode = funcode;
//	m_tx_data.buf_num = num;
//	switch (m_txinfo.funcode)
//	{
//		case FUNCODE_05:
//				break;
//		case FUNCODE_0F:
//				break;
//		case FUNCODE_06:
//		case FUNCODE_10:
//				for(int i = 0;i < m_tx_data.buf_num;i++)
//					m_tx_data.buf_rwdata[i] = *(buf + i);
//				break;
//		default:
//			break;
//	}
//	M_ask_tx_data(m_txinfo,m_tx_data);
//}
#endif /*MODBUS*/

#if MODBUS_TCP
/************************************************
函数名称 ： refresh_info
功    能 ：刷新信息帧，清楚记录
参    数 ：info 发送信息帧或者接收信息帧
返 回 值 ：
*************************************************/
void rerequest(INFO_COMBINATION *sum_info)
{
	sum_info->send_count++;
	if(sum_info->send_count <= SEND_MAX)                                            //重发次数未超时，重发，本次请求还未清除，可以直接用
		M_ask_tx_data_TCP(&(sum_info->txinfo),&(sum_info->tx_data),&(sum_info->master_status));
	else                                                                  //超出重试次数，放弃请求 本次请求，响应清空，重置重发次数
	{
		sum_info->master_status = ABANDON_REQUEST;
		refresh_info(sum_info);
		sum_info->send_count = 0;
	}
}
/************************************************
函数名称 ： M_GetFrameInfo_TCP
功    能 ：获取接收到帧的信息
参    数 ：pdata 接收到的信息   len 接收到的信息长度   *m_recvinfo 分解后信息存入这个结构体指针
返 回 值 ：
*************************************************/
static void M_GetFrameInfo_TCP(uint8_t *pdata,uint8_t len,FRAME_INFO *m_recvinfo)
{
	m_recvinfo->event_code = (*(pdata + 0) << 8) | (*(pdata + 1));        //事务标识码
	m_recvinfo->device_address = *(pdata + 6);                            //单位标识码=从站地址
	m_recvinfo->funcode = *(pdata + 7);                                   //功能码
	m_recvinfo->pdata = pdata+8;                                          //指向具体数据
}
/************************************************
函数名称 ： M_Analyse_info_TCP
功    能 ： 分析接收到modbus tcp的信息帧
参    数 ： p 接收缓存首地址   len  接收数据长度
返 回 值 ： 无
*************************************************/
uint8_t M_Analyse_info_TCP(uint8_t *p,uint8_t Len,INFO_COMBINATION *sum_info)
{
	// 为m_recvinfo的指针成员分配内存,MODBUS最大数据长度250，避免内存泄漏和悬挂指针问题，使用结束释放内存
	sum_info->recvinfo.pdata = (uint8_t *)malloc(250);
	if(sum_info->recvinfo.pdata == NULL)                                   // 检查内存分配是否成功
	{
		printf("memory allocation failure");
		return 0;                                                          // 返回错误代码
	}
	if(Len < FIXEDLEN)                                                     //不足一帧数据最小长度,返回0
		return 0;
	M_GetFrameInfo_TCP(p,Len,&sum_info->recvinfo);                         //获取信息帧内容

	if(sum_info->recvinfo.event_code == sum_info->txinfo.event_code)       //事务标识码对应
	{
		if(sum_info->recvinfo.device_address == sum_info->txinfo.device_address)  //设备地址对应
		{
			M_Dealwith(sum_info);                                             //获取接收数据域中的内容  处理对应功能码及应答
			return 1;
		}
		else
			return 0;
	}
	else
		return 0;
}
/************************************************
函数名称 ： M_ask_tx_data_TCP
功    能 ： 请求新数据 TCP
参    数 ：请求数据的信息
返 回 值 ： 无
*************************************************/
void M_ask_tx_data_TCP(FRAME_INFO *tx_info,M_DATA_INFO *tx_data_info,MASTER_STATUS_T *master_status)
{
	uint8_t askp[40] = {0};                                        //应答缓存    （包含CRC）
	uint8_t i=0;
	askp[i++] = tx_info->event_code >> 8;
	askp[i++] = tx_info->event_code;                               //事务标识码
	askp[i++] = 0;
	askp[i++] = 0;                                                 //协议标识符 0x00 modbus tcp

	switch(tx_info->funcode)
	{
		case(FUNCODE_01):
		case(FUNCODE_02):
		case(FUNCODE_03):
		case(FUNCODE_04):
					askp[i++] = 6;                                   //从单位标识码（从站地址）后的数据长度
					askp[i++] = tx_info->device_address;             //从站地址
					askp[i++] = tx_info->funcode;                    //功能码
					askp[i++] = tx_data_info->buf_header_add >> 8;   //线圈/寄存器起始位置高字节
					askp[i++] = tx_data_info->buf_header_add;        //线圈/寄存器起始位置低字节
					askp[i++] = tx_data_info->buf_num >> 8;          //读取线圈/寄存器数量高字节
					askp[i++] = tx_data_info->buf_num;               //读取线圈/寄存器数量低字节
					break;
		case(FUNCODE_05):
		case(FUNCODE_06):
					askp[i++] = 6;                                   //从单位标识码（从站地址）后的数据长度
					askp[i++] = tx_info->device_address;             //从站地址
					askp[i++] = tx_info->funcode;                    //功能码
					askp[i++] = tx_data_info->buf_header_add >> 8;   //线圈/寄存器起始位置高字节
					askp[i++] = tx_data_info->buf_header_add;        //线圈/寄存器起始位置低字节
					askp[i++] = tx_data_info->buf_rwdata[0] >> 8;    //写入一个线圈/寄存器的高字节
					askp[i++] = tx_data_info->buf_rwdata[0];         //写入一个线圈/寄存器的低字节
					break;
		case(FUNCODE_0F):
					tx_data_info->data_len = tx_data_info->buf_num / 8;
					if(tx_data_info->buf_num % 8)
						tx_data_info->data_len++;
					askp[i++] = tx_data_info->data_len + 7;          //从单位标识码（从站地址）后的数据长度
					askp[i++] = tx_info->device_address;             //从站地址
					askp[i++] = tx_info->funcode;                    //功能码
					askp[i++] = tx_data_info->buf_header_add >> 8;   //线圈/寄存器起始位置高字节
					askp[i++] = tx_data_info->buf_header_add;        //线圈/寄存器起始位置低字节
					askp[i++] = tx_data_info->buf_num >> 8;          //写入线圈数量
					askp[i++] = tx_data_info->buf_num;
					askp[i++] = tx_data_info->data_len;              //写入数据字节数 （线圈数量/8 + （线圈数量%8)）
					for(int j = 0;j < tx_data_info->data_len;j++)
						askp[i + j] = tx_data_info->buf_rwdata[j];
					i += tx_data_info->data_len;
					break;
		case(FUNCODE_10):
					tx_data_info->data_len = tx_data_info->buf_num * 2;
					askp[i++] = tx_data_info->data_len + 7;          //从单位标识码（从站地址）后的数据长度
					askp[i++] = tx_info->device_address;             //从站地址
					askp[i++] = tx_info->funcode;                    //功能码
					askp[i++] = tx_data_info->buf_header_add >> 8;   //线圈/寄存器起始位置高字节
					askp[i++] = tx_data_info->buf_header_add;        //线圈/寄存器起始位置低字节
					askp[i++] = tx_data_info->buf_num >> 8;           //写入寄存器数量
					askp[i++] = tx_data_info->buf_num;
					askp[i++] = tx_data_info->data_len;               //写入数据字节数(一个数据2字节)  （寄存器数量*2）
					for(int j = 0,a = 0;j < tx_data_info->data_len;j += 2)
					{
						askp[i + j] = tx_data_info->buf_rwdata[a] >> 8;
						askp[i + j + 1] = tx_data_info->buf_rwdata[a];
						a++;
					}
					i += tx_data_info->data_len;
		default:    break;
	}

#if RS232_232_1 || MODBUS_232_1
	Send_Data(&huart1,askp,i);
#endif
#if MODBUS_485
	Send_Data(&huart6,askp,i);
#endif
#if MODBUS_NB_IOT
	Send_Data(&huart4,askp,i);
#endif /*MODBUS_NB_IOT*/
#if MODBUS_4G_CAT1
	Send_Data(&huart2,askp,i);
#endif /*MODBUS_4G_CAT*/

	time_count = 0;                                                 //重新响应计时
	*master_status = START_REQUEST;                                 //主站状态，开始请求
}


/************************************************
函数名称 ： M_achieves_read_TCP
功    能 ： modbus主站测试读取TCP       功能码0x01-0x04
参    数 ：funcode 功能码
			buf_add 寄存器/线圈首地址
			num 寄存器/线圈个数
返 回 值 ： 无
*************************************************/
void M_achieves_read_TCP(uint16_t device_address,FUNCODE_T funcode,uint16_t buf_add,uint8_t num,INFO_COMBINATION *sum_info)
{
	sum_info->txinfo.device_address = device_address;
	sum_info->txinfo.funcode = funcode;
	sum_info->txinfo.event_code++;
	sum_info->tx_data.buf_header_add = buf_add;
	sum_info->tx_data.buf_num = num;
	M_ask_tx_data_TCP(&(sum_info->txinfo),&(sum_info->tx_data),&(sum_info->master_status));
}

/************************************************
函数名称 ： M_achieves_write_TCP
功    能 ： modbus主站测试写入 TCP      功能码5 6 15 16
参    数 ：funcode 功能码
			buf_add 寄存器/线圈首地址
			num 寄存器/线圈个数
			buf 写入数据
返 回 值 ： 无
*************************************************/
void M_achieves_write_TCP(uint16_t device_address,FUNCODE_T funcode,uint16_t buf_add,uint8_t num,uint16_t *buf, INFO_COMBINATION *sum_top)
{
	sum_top->txinfo.device_address = device_address;
	sum_top->tx_data.buf_header_add = buf_add;
	sum_top->txinfo.event_code++;
	sum_top->txinfo.funcode = funcode;
	sum_top->tx_data.buf_num = num;
	switch (sum_top->txinfo.funcode)
	{
		case FUNCODE_05:
				break;
		case FUNCODE_0F:
				break;
		case FUNCODE_06:
		case FUNCODE_10:
				for(int i = 0;i < sum_top->tx_data.buf_num;i++)
					sum_top->tx_data.buf_rwdata[i] = *(buf + i);
				break;
		default:
			break;
	}
	M_ask_tx_data_TCP(&(sum_top->txinfo),&(sum_top->tx_data),&(sum_top->master_status));
}

#endif /*MODBUS TCP*/
/************************************************
函数名称 ： M_Dealwith
功    能 ： 获取接收域数据域中的信息   线圈/寄存器地址  数量  数据    处理对应功能号及应答
参    数 ： codeid功能码
返 回 值 ： 无
*************************************************/
void M_Dealwith(INFO_COMBINATION *sum_info)
{
	switch(sum_info->recvinfo.funcode)
	{
	   //功能码1-4 读取线圈寄存器
		case(FUNCODE_01):
		case(FUNCODE_02):sum_info->rx_data.data_len = *(sum_info->recvinfo.pdata + 0);			                        //读取的寄存器数据字节数
				   for(int i = 0;i < sum_info->rx_data.data_len;i++)                                                    //读取寄存器的数据
					   sum_info->rx_data.buf_rwdata[i] = *(sum_info->recvinfo.pdata + i + 1);

#if NON_INTERRUPT_PROCESS == 0
				   if(M_check_code01_02(&(sum_info->rx_data), &(sum_info->tx_data),  sum_info->rebuf))                  //返回错误，重发请求
				   {
					   rerequest(sum_info);
				   }
				   else
				   {
					   sum_info->master_status = FINISH;                                                                //本次请求完成
					   refresh_info(sum_info);                                                                          //清除本次请求 响应
					   sum_info->send_count = 0;                                                                        //从站信息正常，清除重发次数
				   }
#endif  /*NON_INTERRUPT_PROCESS*/

				   break;
		case(FUNCODE_03):
		case(FUNCODE_04):sum_info->rx_data.data_len = *(sum_info->recvinfo.pdata + 0);			                        //读取的寄存器数据字节数
				   for(int i = 0;i < sum_info->rx_data.data_len/2;i++)                                                  //读取寄存器的数据
					   sum_info->rx_data.buf_rwdata[i] = (*(sum_info->recvinfo.pdata + 1 + i*2)<<8)|(*(sum_info->recvinfo.pdata + 1 + i*2 + 1));

#if NON_INTERRUPT_PROCESS == 0
				   if(M_check_code03_04(&(sum_info->rx_data), &(sum_info->tx_data),  sum_info->rebuf))                  //返回错误，重发请求
				   {
					   rerequest(sum_info);
				   }
				   else
				   {
					   sum_info->master_status = FINISH;                                                                //本次请求完成
					   refresh_info(sum_info);                                                                          //清除本次请求 响应
					   sum_info->send_count = 0;                                                                        //从站信息正常，清除重发次数
				   }
#endif  /*NON_INTERRUPT_PROCESS*/
				   break;

	   //功能码5，6 写入线圈/寄存器   写单个
		case(FUNCODE_05):
		case(FUNCODE_06):sum_info->rx_data.buf_header_add = (*(sum_info->recvinfo.pdata + 0)<<8)|(*(sum_info->recvinfo.pdata + 1));         //寄存器首地址
					sum_info->rx_data.buf_num = 1;                                                     //寄存器数量
					sum_info->rx_data.buf_rwdata[0] = (*(sum_info->recvinfo.pdata + 2)<<8)|(*(sum_info->recvinfo.pdata + 3));                //主站写入的线圈/寄存器的数据

#if NON_INTERRUPT_PROCESS == 0
				   if(M_check_code05_06(&(sum_info->rx_data), &(sum_info->tx_data), sum_info->rebuf))                                      //返回错误，重发请求
				   {
					   rerequest(sum_info);
				   }
				   else
				   {
					   sum_info->master_status = FINISH;                                               //本次请求完成
					   refresh_info(sum_info);                                                       //清除本次请求 响应
					   sum_info->send_count = 0;                                                       //从站信息正常，清除重发次数
				   }
#endif  /*NON_INTERRUPT_PROCESS*/
				   break;

	   //功能码15，16 写入寄存器  多个
		case(FUNCODE_0F):
		case(FUNCODE_10):sum_info->rx_data.buf_header_add = (*(sum_info->recvinfo.pdata + 0)<<8)|(*(sum_info->recvinfo.pdata + 1));         //寄存器首地址
					sum_info->rx_data.buf_num = (*(sum_info->recvinfo.pdata + 2)<<8)|(*(sum_info->recvinfo.pdata + 3));                      //寄存器数量

#if NON_INTERRUPT_PROCESS == 0
				   if(M_check_code0f_10(&(sum_info->rx_data), &(sum_info->tx_data),  sum_info->rebuf))                                     //返回错误，重发请求
				   {
					   rerequest(sum_info);
				   }
				   else
				   {
					   sum_info->master_status = FINISH;                                               //本次请求完成
					   refresh_info(sum_info);                                                       //清除本次请求 响应
					   sum_info->send_count = 0;                                                       //从站信息正常，清除重发次数
				   }
#endif /*NON_INTERRUPT_PROCESS*/
				   break;
		case(ERRORCODE_01):
		case(ERRORCODE_02):
		case(ERRORCODE_03):
		case(ERRORCODE_04):
		case(ERRORCODE_05):
		case(ERRORCODE_06):
		case(ERRORCODE_0F):
		case(ERRORCODE_10):sum_info->rx_data.exception_code = *(sum_info->recvinfo.pdata + 0);                           //异常码
				   M_error_code(sum_info);
				   break;
		default:   break;
	}
}
//void M_Dealwith(uint8_t *pdata)
//{
//	switch(m_recvinfo.funcode)
//	{
//	   //功能码1-4 读取线圈寄存器
//		case(FUNCODE_01):
//		case(FUNCODE_02):m_rx_data.data_len = *(pdata + 0);			                         //读取的寄存器数据字节数
//				   for(int i = 0;i < m_rx_data.data_len;i++)                                 //读取寄存器的数据
//					   m_rx_data.buf_rwdata[i] = *(pdata + i + 1);
//
//				   if(M_check_code01_02())                                                 //返回错误，重发请求
//				   {
//					   rerequest();
//				   }
//				   else
//				   {
//					   master_status = FINISH;                                               //本次请求完成
//					   refresh_info();                                                       //清除本次请求 响应
//					   send_count = 0;                                                       //从站信息正常，清除重发次数
//				   }
//				   break;
//		case(FUNCODE_03):
//		case(FUNCODE_04):m_rx_data.data_len = *(pdata + 0);			                         //读取的寄存器数据字节数
//				   for(int i = 0;i < m_rx_data.data_len/2;i++)                               //读取寄存器的数据
//					   m_rx_data.buf_rwdata[i] = (*(pdata + 1 + i*2)<<8)|(*(pdata + 1 + i*2 + 1));
//
//				   if(M_check_code03_04())                                                 //返回错误，重发请求
//				   {
//					   rerequest();
//				   }
//				   else
//				   {
//					   master_status = FINISH;                                               //本次请求完成
//					   refresh_info();                                                       //清除本次请求 响应
//					   send_count = 0;                                                       //从站信息正常，清除重发次数
//				   }
//				   break;
//
//	   //功能码5，6 写入线圈/寄存器   写单个
//		case(FUNCODE_05):
//		case(FUNCODE_06):m_rx_data.buf_header_add = (*(pdata + 0)<<8)|(*(pdata + 1));         //寄存器首地址
//				   m_rx_data.buf_num = 1;                                                     //寄存器数量
//				   m_rx_data.buf_rwdata[0] = (*(pdata + 2)<<8)|(*(pdata + 3));                //主站写入的线圈/寄存器的数据
//
//				   if(M_check_code05_06())                                                 //返回错误，重发请求
//				   {
//					   rerequest();
//				   }
//				   else
//				   {
//					   master_status = FINISH;                                               //本次请求完成
//					   refresh_info();                                                       //清除本次请求 响应
//					   send_count = 0;                                                       //从站信息正常，清除重发次数
//				   }
//				   break;
//
//	   //功能码15，16 写入寄存器  多个
//		case(FUNCODE_0F):
//		case(FUNCODE_10):m_rx_data.buf_header_add = (*(pdata + 0)<<8)|(*(pdata + 1));         //寄存器首地址
//				   m_rx_data.buf_num = (*(pdata + 2)<<8)|(*(pdata + 3));                      //寄存器数量
//
//				   if(M_check_code0f_10())                                                 //返回错误，重发请求
//				   {
//					   rerequest();
//				   }
//				   else
//				   {
//					   master_status = FINISH;                                               //本次请求完成
//					   refresh_info();                                                       //清除本次请求 响应
//					   send_count = 0;                                                       //从站信息正常，清除重发次数
//				   }
//				   break;
//		case(ERRORCODE_01):
//		case(ERRORCODE_02):
//		case(ERRORCODE_03):
//		case(ERRORCODE_04):
//		case(ERRORCODE_05):
//		case(ERRORCODE_06):
//		case(ERRORCODE_0F):
//		case(ERRORCODE_10):m_rx_data.exception_code = *(pdata + 0);                           //异常码
//				   M_error_code();
//				   break;
//		default:   break;
//	}
//}



/************************************************
函数名称 ： M_check_code01_02
功    能 ： 检查响应 功能码01--读线圈状态   02--读输入状态
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code01_02(M_DATA_INFO *rx_data, M_DATA_INFO *tx_data, uint16_t *rebuf)
{
	uint8_t num_bit = 0;                                                  //线圈数量对应的字节数
	num_bit = tx_data->buf_num/8;
	if(tx_data->buf_num % 8)
		num_bit++;

	if(rx_data->data_len == num_bit)                                     //检查字节数是否正确
	{

#if READ_ALL
		if(read_buf_len == 0)
		{
			rebuf[0] = 10;                                               //表示线圈
			rebuf[1] = COIL_GT600_ETHERNET_FAULT;
			rebuf[2] = 88;
			read_buf_len += 3;
		}
		else if(read_buf_len == 14)
		{
			rebuf[14] = 10;                                               //表示线圈
			rebuf[15] = COIL_FREQUENCY_CONVERSION_CON_FAULT;
			rebuf[16] = 3;
			read_buf_len += 3;
		}
		else if(read_buf_len == 18)
		{
			rebuf[18] = 10;                                               //表示线圈
			rebuf[19] = COIL_EXCESSIVE_POSITION_DEVIATION;
			rebuf[20] = 1;
			read_buf_len += 3;
		}
		for(int i = 0;i < rx_data->data_len;i++)
			rebuf[i + read_buf_len] = rx_data->buf_rwdata[i];
		read_buf_len += rx_data->data_len;
#endif  /*READ_ALL*/
		return 0;
	}
	return 1;
}
//uint8_t M_check_code01_02(void)
//{
//	uint8_t num_bit = 0;                                                  //线圈数量对应的字节数
//	num_bit = m_tx_data.buf_num/8;
//	if(m_tx_data.buf_num % 8)
//		num_bit++;
//
//	if(m_rx_data.data_len == num_bit)                                     //检查字节数是否正确
//	{
////		for(int j = 0;j < m_rx_data.data_len;j++)                         //读取到的线圈状态(每一位分开存放)放入线圈缓冲区中，从读取线圈起始位置开始
////		{
////			for(int i = 0;i < 8;i++)
////				coil_state[j*8 + m_tx_data.buf_header_add + i] = ((m_rx_data.buf_rwdata[j] << (7-i))&0x00ff) >> 7;
////		}
//#if READ_ALL
//		if(read_buf_len == 0)
//		{
//			rebuf_into[0] = 10;                                               //表示线圈
//			rebuf_into[1] = COIL_GT600_ETHERNET_FAULT;
//			rebuf_into[2] = 88;
//			read_buf_len += 3;
//		}
//		else if(read_buf_len == 14)
//		{
//			rebuf_into[14] = 10;                                               //表示线圈
//			rebuf_into[15] = COIL_FREQUENCY_CONVERSION_CON_FAULT;
//			rebuf_into[16] = 3;
//			read_buf_len += 3;
//		}
//		else if(read_buf_len == 18)
//		{
//			rebuf_into[18] = 10;                                               //表示线圈
//			rebuf_into[19] = COIL_EXCESSIVE_POSITION_DEVIATION;
//			rebuf_into[20] = 1;
//			read_buf_len += 3;
//		}
//		for(int i = 0;i < m_rx_data.data_len;i++)
//			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
//		read_buf_len += m_rx_data.data_len;
//#endif
//		return 0;
//	}
//	return 1;
//}
/************************************************
函数名称 ： M_check_code03_04
功    能 ： 检查响应 功能码03--读保持寄存器   04--读输入寄存器
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code03_04(M_DATA_INFO *rx_data, M_DATA_INFO *tx_data, uint16_t *rebuf)
{
	if((rx_data->data_len / 2) == tx_data->buf_num)                                  //检查返回字节数和请求的寄存器数量是否一致 字节数=寄存器数量*2
	{
#if READ_ALL
		if (read_buf_len == 22)
		{
			rebuf[22] = 11;                                               //表示寄存器
			rebuf[23] = REG_CURRENT_WARP_LEN;
			rebuf[24] = 5;
			read_buf_len += 3;
		}
		else if(read_buf_len == 30)
		{
			rebuf[30] = 11;                                               //表示寄存器
			rebuf[31] = REG_CURRENT_NUM_LINES;
			rebuf[32] = 1;
			read_buf_len += 3;
		}
		else if(read_buf_len == 34)
		{
			rebuf[34] = 11;                                               //表示寄存器
			rebuf[35] = REG_BAR_WIDTH_VALUE;
			rebuf[36] = 4;
			read_buf_len += 3;
		}
		else if(read_buf_len == 41)
		{
			rebuf[41] = 11;                                               //表示寄存器
			rebuf[42] = REG_DISPLACEMENT;
			rebuf[43] = 4;
			read_buf_len += 3;
		}
		for(int i = 0;i < rx_data->data_len/2;i++)
			rebuf[i + read_buf_len] = rx_data->buf_rwdata[i];
		read_buf_len += tx_data->buf_num;
		if(read_buf_len == 48)
		{
			tran_modbus(rebuf,read_buf_len);
			read_buf_len = 0;
		}

#endif  /*READ_ALL*/
		return 0;
	}
	return 1;
}
//uint8_t M_check_code03_04(void)
//{
//
//	if((m_rx_data.data_len / 2) == m_tx_data.buf_num)                                  //检查返回字节数和请求的寄存器数量是否一致 字节数=寄存器数量*2
//	{
//#if READ_ALL
//		if (read_buf_len == 22)
//		{
//			rebuf_into[22] = 11;                                               //表示寄存器
//			rebuf_into[23] = REG_CURRENT_WARP_LEN;
//			rebuf_into[24] = 5;
//			read_buf_len += 3;
//		}
//		else if(read_buf_len == 30)
//		{
//			rebuf_into[30] = 11;                                               //表示寄存器
//			rebuf_into[31] = REG_CURRENT_NUM_LINES;
//			rebuf_into[32] = 1;
//			read_buf_len += 3;
//		}
//		else if(read_buf_len == 34)
//		{
//			rebuf_into[34] = 11;                                               //表示寄存器
//			rebuf_into[35] = REG_BAR_WIDTH_VALUE;
//			rebuf_into[36] = 4;
//			read_buf_len += 3;
//		}
//		else if(read_buf_len == 41)
//		{
//			rebuf_into[41] = 11;                                               //表示寄存器
//			rebuf_into[42] = REG_DISPLACEMENT;
//			rebuf_into[43] = 4;
//			read_buf_len += 3;
//		}
//		for(int i = 0;i < m_rx_data.data_len/2;i++)
//			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
//		read_buf_len += m_tx_data.buf_num;
//		if(read_buf_len == 48)
//		{
//			tran_modbus(rebuf_into,read_buf_len);
//			read_buf_len = 0;
//		}
////		if (read_buf_len == 0)
////		{
////			rebuf_into[0] = DEVICE_STATUS_ADDR;
////			rebuf_into[1] = 31;
////			read_buf_len += 2;
////		}
////		else if(read_buf_len == 33)
////		{
////			rebuf_into[33] = LOOM_LET_OFF_SERVO_OUT_V;
////			rebuf_into[34] = 4;
////			read_buf_len += 2;
////		}
////		else if(read_buf_len == 39)
////		{
////			rebuf_into[39] = LOWER_BEAM_SUM_LENGTH_ADDR_L;
////			rebuf_into[40] = 79;
////			read_buf_len += 2;
////		}
////		for(int i = 0;i < m_rx_data.data_len/2;i++)
////			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
////		read_buf_len += m_tx_data.buf_num;
////		if(read_buf_len == 120)
////		{
////			tran_modbus(rebuf_into,read_buf_len);
////			read_buf_len = 0;
////		}
//#else
//		if (read_buf_len == 0)
//		{
//			rebuf_into[0] = DEVICE_STATUS_ADDR;
//			rebuf_into[1] = 6;
//			read_buf_len += 2;
//		}
//		else if(read_buf_len == 8)
//		{
//			rebuf_into[8] = ROTATE_SPEED_ADDR;
//			rebuf_into[9] = 1;
//			read_buf_len += 2;
//		}
//		else if(read_buf_len == 11)
//		{
//			rebuf_into[11] = DEVICE_STOP_TYPE_ADDR;
//			rebuf_into[12] = 1;
//			read_buf_len += 2;
//		}
//		else if(read_buf_len == 14)
//		{
//			rebuf_into[11] = LOOM_LET_OFF_SERVO_OUT_V;
//			rebuf_into[12] = 4;
//			read_buf_len += 2;
//		}
//		for(int i = 0;i < m_rx_data.data_len/2;i++)
//			rebuf_into[i + read_buf_len] = m_rx_data.buf_rwdata[i];
//		read_buf_len += m_tx_data.buf_num;
//		if(read_buf_len == 20)
//		{
//			tran_modbus(rebuf_into,read_buf_len);
//			read_buf_len = 0;
//		}
//#endif
//			//经过汇川程序检测后，清除本次请求和响应
//		return 0;
//	}
//	return 1;
//}
/************************************************
函数名称 ： M_check_code05_06
功    能 ： 检查响应 功能码05--写单个线圈状态  功能码06--写单个寄存器状态   检查与发送是否相同
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code05_06(M_DATA_INFO *rx_data, M_DATA_INFO *tx_data, uint16_t *rebuf)
{
	if(rx_data->buf_header_add == tx_data->buf_header_add)
	{
		if(rx_data->buf_rwdata[0] == tx_data->buf_rwdata[0])
		{
			//检验成功，本次请求完成，清除本次的请求和响应
			return 0;
		}
	}
	return 1;
}
//uint8_t M_check_code05_06(void)
//{
//	if(m_rx_data.buf_header_add == m_tx_data.buf_header_add)
//	{
//		if(m_rx_data.buf_rwdata[0] == m_tx_data.buf_rwdata[0])
//		{
//			//检验成功，本次请求完成，清除本次的请求和响应
//			return 0;
//		}
//	}
//	return 1;
//}
/*************************************************
函数名称 ： M_check_code0f
功    能 ： 检查响应 功能码0f--写多个线圈状态  功能码10--写多个寄存器状态  检查与发送是否相同
参    数 ： 无
返 回 值 ： 0 无错误   1有错误 重发请求
*************************************************/
uint8_t M_check_code0f_10(M_DATA_INFO *rx_data, M_DATA_INFO *tx_data, uint16_t *rebuf)
{
	if(rx_data->buf_header_add == tx_data->buf_header_add)
	{
		if(rx_data->buf_num == tx_data->buf_num)
		{
			//检验成功，本次请求完成，清除本次的请求和响应
			return 0;
		}
	}
	return 1;
}
//uint8_t M_check_code0f_10(void)
//{
//	if(m_rx_data.buf_header_add == m_tx_data.buf_header_add)
//	{
//		if(m_rx_data.buf_num == m_tx_data.buf_num)
//		{
//			//检验成功，本次请求完成，清除本次的请求和响应
//			return 0;
//		}
//	}
//	return 1;
//}
/*************************************************
函数名称 ： M_error_code
功    能 ： 异常处理 要不要延时等待什么的
参    数 ： sum_info 总体收发信息
返 回 值 ： 无
*************************************************/
void M_error_code(INFO_COMBINATION *sum_info)
{
	if ((sum_info->rx_data.exception_code == DEVICE_COF)|
		(sum_info->rx_data.exception_code == DEVICE_BUSY))
	{
		sum_info->send_count = 0;                                                            //从站信息正常，清除重发次数
		//延长等待，清除计数
		time_count = 0;
	}
	else                                                                           //其他错误，重新请求
		rerequest(sum_info);
}
//void M_error_code(void)
//{
//	if ((m_rx_data.exception_code == DEVICE_COF)|
//		(m_rx_data.exception_code == DEVICE_BUSY))
//	{
//		send_count = 0;                                                            //从站信息正常，清除重发次数
//		//延长等待，清除计数
//		time_count = 0;
//	}
//	else                                                                           //其他错误，重新请求
//		rerequest();
//}
/************************************************
函数名称 ： M_timeout
功    能 ： 响应超时处理函数   1000ms    在已发送请求的情况下查询
参    数 ：
返 回 值 ： 无
*************************************************/
void M_timeout(FRAME_INFO *tx_info,M_DATA_INFO *tx_data_info,uint8_t *send_count,MASTER_STATUS_T *master_status)
{
	if(*master_status == START_REQUEST)
	{
		if (time_count > 20)                                          //超时
		{
			(*send_count)++;
			if(*send_count <= SEND_MAX)                                //重发次数未超时，重发，本次请求还未清除，可以直接用
			{
				M_ask_tx_data(tx_info,tx_data_info,master_status);
			}
		}
	}
}

/************************************************
函数名称 ： test_read
功    能 ： 测试读取
参    数 ：
返 回 值 ： 无
*************************************************/
void test_read(void)
{
//#if READ_ALL
//	if(read_finish == 0)
//		{
//			if(device_read_addr == COIL_GT600_ETHERNET_FAULT)
//			{
//				M_achieves_read(FUNCODE_01,device_read_addr,88);                                   //初次请求，从线圈M421开始读取88个
//				device_read_addr = COIL_FREQUENCY_CONVERSION_CON_FAULT;
//			}
//			if ((master_status == FINISH)|
//				(master_status == ABANDON_REQUEST))                                                //当上一次请求完成或放弃，更改请求，发送下一次请求
//			{
//
//				if (device_read_addr == COIL_FREQUENCY_CONVERSION_CON_FAULT)                       //读取线圈M5030部分   3个
//				{
//					M_achieves_read(FUNCODE_01,device_read_addr,3);
//					device_read_addr = COIL_EXCESSIVE_POSITION_DEVIATION;
//				}
//				else if (device_read_addr == COIL_EXCESSIVE_POSITION_DEVIATION)                   //读取线圈M6177部分  1个
//				{
//					M_achieves_read(FUNCODE_01,device_read_addr,1);
//					device_read_addr = REG_CURRENT_WARP_LEN;
//				}
//				else if (device_read_addr == REG_CURRENT_WARP_LEN)                                 //读取寄存器D1402部分 5个
//				{
//					M_achieves_read(FUNCODE_03,device_read_addr,5);
//					device_read_addr = REG_CURRENT_NUM_LINES;
//				}
//				else if (device_read_addr == REG_CURRENT_NUM_LINES)                                 //读取寄存器D1425部分 1个
//				{
//					M_achieves_read(FUNCODE_03,device_read_addr,1);
//					device_read_addr = REG_BAR_WIDTH_VALUE;
//				}
//				else if (device_read_addr == REG_BAR_WIDTH_VALUE)                                  //读取寄存器D1508部分 4个
//				{
//					M_achieves_read(FUNCODE_03,device_read_addr,4);
//					device_read_addr = REG_DISPLACEMENT;
//				}
//				else if (device_read_addr == REG_DISPLACEMENT)                                  //读取寄存器D1600部分 4个
//				{
//					M_achieves_read(FUNCODE_03,device_read_addr,4);
//					device_read_addr = COIL_GT600_ETHERNET_FAULT;
//					read_finish = 1;
//				}
//			}
//		}
//#endif
}
/************************************************
函数名称 ： test_write
功    能 ： 测试写入
参    数 ：
返 回 值 ： 无
*************************************************/
void test_write(void)
{
//	uint16_t aa = 0xFF;
//	if(device_write_addr == LOWER_BEAM_SUM_LENGTH_ADDR_L)
//	{
//		M_achieves_write(FUNCODE_06,device_write_addr,1,&aa);                                   //初次请求，写入一个
//		device_write_addr += 2;
//	}
//	if ((master_status == FINISH)|
//		(master_status == ABANDON_REQUEST))                                                     //当上一次请求完成或放弃，更改请求，发送下一次请求
//	{
//		device_write_addr += 10;
//		if(device_write_addr < CLOTH_FALLING_TIME_ADDR_S )
//			M_achieves_write(FUNCODE_06,device_write_addr,1,&aa);
//	}

//	uint16_t buf[10]={0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA6,0xA8,0xA9};
//	if(device_write_addr == LOWER_BEAM_SUM_LENGTH_ADDR_L)
//	{
//		device_write_addr += 2;
//		M_achieves_write(FUNCODE_10,device_write_addr,10,buf);                                   //初次请求，写入10个
//	}
//	if ((master_status == FINISH)|
//		(master_status == ABANDON_REQUEST))                                                     //当上一次请求完成或放弃，更改请求，发送下一次请求
//	{
//		device_write_addr += 10;
//		if(device_write_addr < CLOTH_FALLING_TIME_ADDR_S )
//			M_achieves_write(FUNCODE_10,device_write_addr,10,buf);
//		else
//		{
//			device_write_addr =  LOWER_BEAM_SUM_LENGTH_ADDR_L;
//			device_write_addr += 2;
//			M_achieves_write(FUNCODE_10,device_write_addr,10,buf);                                   //初次请求，写入10个
//		}
//
//	}
}


#endif  /*MODBUS MODBUS_TCP*/
